package com.asurplus.common.caffeine.utils;

import cn.hutool.core.collection.CollectionUtil;
import com.asurplus.common.caffeine.cache.SysDictCaffeineCache;
import com.asurplus.common.consts.CacheConst;
import com.asurplus.system.entity.SysDictDetail;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * 数据字典缓存工具类
 */
@Component
public class SysDictCaffeineCacheUtils {

    @Autowired
    private SysDictCaffeineCache<Object> sysDictCaffeineCache;

    /**
     * 获取字典明细数据
     */
    public String getDictDetailName(String dictCode, String code) {
        if (StringUtils.isBlank(dictCode) || StringUtils.isBlank(code)) {
            return null;
        }
        // 新建一个map
        Map<String, String> map = null;
        // 从本地缓存中获取
        Object object = sysDictCaffeineCache.get(CacheConst.SYS_DICT_CACHE + dictCode);
        // 如果为空
        if (null == object) {
            map = new LinkedHashMap<>();
        } else {
            map = (LinkedHashMap<String, String>) object;
        }
        if (CollectionUtil.isEmpty(map)) {
            return null;
        }
        return map.get(code);
    }

    /**
     * 获取字典明细数据
     */
    public List<SysDictDetail> listSysDictDetail(String dictCode) {
        if (StringUtils.isBlank(dictCode)) {
            return null;
        }
        // 新建一个map
        Map<String, String> map = null;
        // 从本地缓存中获取
        Object object = sysDictCaffeineCache.get(CacheConst.SYS_DICT_CACHE + dictCode);
        // 如果为空
        if (null == object) {
            map = new LinkedHashMap<>();
        } else {
            map = (LinkedHashMap<String, String>) object;
        }
        if (CollectionUtil.isEmpty(map)) {
            return null;
        }
        List<SysDictDetail> list = new ArrayList<>();
        SysDictDetail sysDictDetail;
        for (String item : map.keySet()) {
            sysDictDetail = new SysDictDetail();
            sysDictDetail.setCode(item);
            sysDictDetail.setName(map.get(item));
            list.add(sysDictDetail);
        }
        return list;
    }

    /**
     * 存入本地缓存
     *
     * @param dictCode
     * @param code
     * @param name
     * @return
     */
    public boolean update(String dictCode, String code, String name) {
        if (StringUtils.isBlank(dictCode) || StringUtils.isBlank(code) || StringUtils.isBlank(name)) {
            return false;
        }
        // 新建一个map
        Map<String, String> map = null;
        // 从本地缓存中获取
        Object object = sysDictCaffeineCache.get(CacheConst.SYS_DICT_CACHE + dictCode);
        // 如果为空
        if (null == object) {
            map = new LinkedHashMap<>();
        } else {
            map = (LinkedHashMap<String, String>) object;
        }
        // 加入map中
        map.put(code, name);
        // 存入本地缓存
        return sysDictCaffeineCache.put(CacheConst.SYS_DICT_CACHE + dictCode, map);
    }

    /**
     * 存入本地缓存
     *
     * @param dictCode
     * @param list
     * @return
     */
    public boolean update(String dictCode, List<SysDictDetail> list) {
        if (StringUtils.isBlank(dictCode) || CollectionUtil.isEmpty(list)) {
            return false;
        }
        // 新建一个map
        Map<String, String> map = new LinkedHashMap<>();
        for (SysDictDetail item : list) {
            map.put(item.getCode(), item.getName());
        }
        // 存入本地缓存
        return sysDictCaffeineCache.put(CacheConst.SYS_DICT_CACHE + dictCode, map);
    }

    /**
     * 删除本地数据
     */
    public boolean delete(String dictCode, String code) {
        if (StringUtils.isBlank(dictCode) || StringUtils.isBlank(code)) {
            return false;
        }
        // 新建一个map
        Map<String, String> map = null;
        // 从本地缓存中获取
        Object object = sysDictCaffeineCache.get(CacheConst.SYS_DICT_CACHE + dictCode);
        // 如果为空
        if (null == object) {
            map = new LinkedHashMap<>();
        } else {
            map = (LinkedHashMap<String, String>) object;
        }
        // 从map中删除
        if (CollectionUtil.isNotEmpty(map)) {
            map.remove(code);
        }
        // 更新本地缓存
        return sysDictCaffeineCache.put(CacheConst.SYS_DICT_CACHE + dictCode, map);
    }

    /**
     * 删除本地数据
     */
    public boolean delete(String dictCode) {
        if (StringUtils.isBlank(dictCode)) {
            return false;
        }
        return sysDictCaffeineCache.delete(CacheConst.SYS_DICT_CACHE + dictCode);
    }
}
